home *** CD-ROM | disk | FTP | other *** search
/ START Magazine / START VOL 3 NO 7.st / KAMIKAZE.ARC / TABLES.C < prev   
Encoding:
C/C++ Source or Header  |  1988-11-14  |  11.0 KB  |  578 lines
  1.  
  2. #include "kamikaze.h"
  3.  
  4.  
  5. extern int check_rook(), check_knight(), check_bishop(),
  6.     check_queen(), check_king(), check_pawn();
  7.  
  8. /**** Start out with some pretty boring tables.  The first set of tables 
  9.   is a list of all concievable moves for each piece.  (Castling is considered a
  10.   king's move) ****/
  11.  
  12. Piece_move rook_moves[] =
  13.     {
  14.         {0, -7},
  15.         {0, -6},
  16.         {0, -5},
  17.         {0, -4},
  18.         {0, -3},
  19.         {0, -2},
  20.         {0, -1},
  21.         {0, 1},
  22.         {0, 2},
  23.         {0, 3},
  24.         {0, 4},
  25.         {0, 5},
  26.         {0, 6},
  27.         {0, 7},
  28.         {-7, 0},
  29.         {-6, 0},
  30.         {-5, 0},
  31.         {-4, 0},
  32.         {-3, 0},
  33.         {-2, 0},
  34.         {-1, 0},
  35.         {1, 0},
  36.         {2, 0},
  37.         {3, 0},
  38.         {4, 0},
  39.         {5, 0},
  40.         {6, 0},
  41.         {7, 0},
  42.     };
  43. Piece_move knight_moves[] =
  44.     {
  45.         {-2, -1},
  46.         {-2, 1},
  47.         {2, -1},
  48.         {2, 1},
  49.         {-1, -2},
  50.         {-1, 2},
  51.         {1, -2},
  52.         {1, 2},
  53.     };
  54. Piece_move bishop_moves[] =
  55.     {
  56.         {-7, -7},
  57.         {-6, -6},
  58.         {-5, -5},
  59.         {-4, -4},
  60.         {-3, -3},
  61.         {-2, -2},
  62.         {-1, -1},
  63.         {1, 1},
  64.         {2, 2},
  65.         {3, 3},
  66.         {4, 4},
  67.         {5, 5},
  68.         {6, 6},
  69.         {7, 7},
  70.         {-7, 7},
  71.         {-6, 6},
  72.         {-5, 5},
  73.         {-4, 4},
  74.         {-3, 3},
  75.         {-2, 2},
  76.         {-1, 1},
  77.         {1, -1},
  78.         {2, -2},
  79.         {3, -3},
  80.         {4, -4},
  81.         {5, -5},
  82.         {6, -6},
  83.         {7, -7},
  84.     };
  85. Piece_move king_moves[] =
  86.     {
  87.         {-1, -1},
  88.         {-1, 0},
  89.         {-1, 1},
  90.         {0, 1},
  91.         {1, 1},
  92.         {1, 0},
  93.         {1, -1},
  94.         {0, -1},
  95.         {0, 2},
  96.         {0, -2},
  97.     };
  98. Piece_move queen_moves[] =
  99.     {
  100.         {0, -7},
  101.         {0, -6},
  102.         {0, -5},
  103.         {0, -4},
  104.         {0, -3},
  105.         {0, -2},
  106.         {0, -1},
  107.         {0, 1},
  108.         {0, 2},
  109.         {0, 3},
  110.         {0, 4},
  111.         {0, 5},
  112.         {0, 6},
  113.         {0, 7},
  114.         {-7, 0},
  115.         {-6, 0},
  116.         {-5, 0},
  117.         {-4, 0},
  118.         {-3, 0},
  119.         {-2, 0},
  120.         {-1, 0},
  121.         {1, 0},
  122.         {2, 0},
  123.         {3, 0},
  124.         {4, 0},
  125.         {5, 0},
  126.         {6, 0},
  127.         {7, 0},
  128.         {-7, -7},
  129.         {-6, -6},
  130.         {-5, -5},
  131.         {-4, -4},
  132.         {-3, -3},
  133.         {-2, -2},
  134.         {-1, -1},
  135.         {1, 1},
  136.         {2, 2},
  137.         {3, 3},
  138.         {4, 4},
  139.         {5, 5},
  140.         {6, 6},
  141.         {7, 7},
  142.         {-7, 7},
  143.         {-6, 6},
  144.         {-5, 5},
  145.         {-4, 4},
  146.         {-3, 3},
  147.         {-2, 2},
  148.         {-1, 1},
  149.         {1, -1},
  150.         {2, -2},
  151.         {3, -3},
  152.         {4, -4},
  153.         {5, -5},
  154.         {6, -6},
  155.         {7, -7},
  156.     };
  157. Piece_move wpawn_moves[4] =
  158.     {
  159.         {0, 1},
  160.         {1, 1},
  161.         {-1, 1},
  162.         {0, 2},
  163.     };
  164. Piece_move bpawn_moves[4] =
  165.     {
  166.         {0, -1},
  167.         {1, -1},
  168.         {-1, -1},
  169.         {0, -2},
  170.     };
  171.  
  172. extern unsigned WORD
  173.     iwhite_pawn[], iwhite_knight[], iwhite_bishop[], iwhite_rook[], 
  174.     iwhite_queen[], iwhite_king[],
  175.     iblack_pawn[], iblack_knight[], iblack_bishop[], iblack_rook[], 
  176.     iblack_queen[], iblack_king[];
  177.  
  178. Piece white_pieces[16];
  179. Piece black_pieces[16];
  180.  
  181. /* These are the data structures for the pieces.  They include the
  182.    board position, info if piece alive, type of piece, color, 
  183.    a name for the piece, an image for the piece, 
  184.    a function to call to see if the piece
  185.    can actually make a potential move (ie is it blocked?), a list
  186.    of all potential moves, the value of the piece (which isn't
  187.    much like normal chess at all, a pawn is worth more than a queen
  188.    since it's harder to get rid of), and finally the index of the
  189.    piece in this array */
  190. Piece w_pieces[16] =
  191.     {
  192.         {
  193.         0, 0, 0, ROOK,
  194.         WHITE,
  195.         "Rk",
  196.         iwhite_rook,
  197.         check_rook,
  198.         rook_moves,
  199.         Array_els(rook_moves),
  200.         6,
  201.         0,
  202.         },
  203.         {
  204.         1, 0, 0, KNIGHT,
  205.         WHITE,
  206.         "Kt",
  207.         iwhite_knight,
  208.         check_knight,
  209.         knight_moves,
  210.         Array_els(knight_moves),
  211.         2,
  212.         1,
  213.         },
  214.         {
  215.         2, 0, 0, BISHOP,
  216.         WHITE,
  217.         "Bp",
  218.         iwhite_bishop,
  219.         check_bishop,
  220.         bishop_moves,
  221.         Array_els(bishop_moves),
  222.         4,
  223.         2,
  224.         },
  225.         {
  226.         3, 0, 0, KING,
  227.         WHITE,
  228.         "Kg",
  229.         iwhite_king,
  230.         check_king,
  231.         king_moves,
  232.         Array_els(king_moves),
  233.         127,
  234.         3,
  235.         },
  236.         {
  237.         4, 0, 0, QUEEN,
  238.         WHITE,
  239.         "Qn",
  240.         iwhite_queen,
  241.         check_queen,
  242.         queen_moves,
  243.         Array_els(queen_moves),
  244.         2,
  245.         4,
  246.         },
  247.         {
  248.         5, 0, 0, BISHOP,
  249.         WHITE,
  250.         "Bp",
  251.         iwhite_bishop,
  252.         check_bishop,
  253.         bishop_moves,
  254.         Array_els(bishop_moves),
  255.         4,
  256.         5,
  257.         },
  258.         {
  259.         6, 0, 0, KNIGHT,
  260.         WHITE,
  261.         "Kt",
  262.         iwhite_knight,
  263.         check_knight,
  264.         knight_moves,
  265.         Array_els(knight_moves),
  266.         2,
  267.         6,
  268.         },
  269.         {
  270.         7, 0, 0, ROOK,
  271.         WHITE,
  272.         "Rk",
  273.         iwhite_rook,
  274.         check_rook,
  275.         rook_moves,
  276.         Array_els(rook_moves),
  277.         6,
  278.         7,
  279.         },
  280.         {
  281.         0, 1, 0, PAWN,
  282.         WHITE,
  283.         "Pn",
  284.         iwhite_pawn,
  285.         check_pawn,
  286.         wpawn_moves,
  287.         Array_els(wpawn_moves),
  288.         3,
  289.         8,
  290.         },
  291.         {
  292.         1, 1, 0, PAWN,
  293.         WHITE,
  294.         "Pn",
  295.         iwhite_pawn,
  296.         check_pawn,
  297.         wpawn_moves,
  298.         Array_els(wpawn_moves),
  299.         3,
  300.         9,
  301.         },
  302.         {
  303.         2, 1, 0, PAWN,
  304.         WHITE,
  305.         "Pn",
  306.         iwhite_pawn,
  307.         check_pawn,
  308.         wpawn_moves,
  309.         Array_els(wpawn_moves),
  310.         3,
  311.         10,
  312.         },
  313.         {
  314.         3, 1, 0, PAWN,
  315.         WHITE,
  316.         "Pn",
  317.         iwhite_pawn,
  318.         check_pawn,
  319.         wpawn_moves,
  320.         Array_els(wpawn_moves),
  321.         3,
  322.         11,
  323.         },
  324.         {
  325.         4, 1, 0, PAWN,
  326.         WHITE,
  327.         "Pn",
  328.         iwhite_pawn,
  329.         check_pawn,
  330.         wpawn_moves,
  331.         Array_els(wpawn_moves),
  332.         3,
  333.         12,
  334.         },
  335.         {
  336.         5, 1, 0, PAWN,
  337.         WHITE,
  338.         "Pn",
  339.         iwhite_pawn,
  340.         check_pawn,
  341.         wpawn_moves,
  342.         Array_els(wpawn_moves),
  343.         3,
  344.         13,
  345.         },
  346.         {
  347.         6, 1, 0, PAWN,
  348.         WHITE,
  349.         "Pn",
  350.         iwhite_pawn,
  351.         check_pawn,
  352.         wpawn_moves,
  353.         Array_els(wpawn_moves),
  354.         3,
  355.         14,
  356.         },
  357.         {
  358.         7, 1, 0, PAWN,
  359.         WHITE,
  360.         "Pn",
  361.         iwhite_pawn,
  362.         check_pawn,
  363.         wpawn_moves,
  364.         Array_els(wpawn_moves),
  365.         3,
  366.         15,
  367.         },
  368.     };
  369.  
  370. Piece b_pieces[16] =
  371.     {
  372.         {
  373.         0, 7, 0, ROOK,
  374.         BLACK,
  375.         "Rk",
  376.         iblack_rook,
  377.         check_rook,
  378.         rook_moves,
  379.         Array_els(rook_moves),
  380.         6,
  381.         0,
  382.         },
  383.         {
  384.         1, 7, 0, KNIGHT,
  385.         BLACK,
  386.         "Kt",
  387.         iblack_knight,
  388.         check_knight,
  389.         knight_moves,
  390.         Array_els(knight_moves),
  391.         2,
  392.         1,
  393.         },
  394.         {
  395.         2, 7, 0, BISHOP,
  396.         BLACK,
  397.         "Bp",
  398.         iblack_bishop,
  399.         check_bishop,
  400.         bishop_moves,
  401.         Array_els(bishop_moves),
  402.         4,
  403.         2,
  404.         },
  405.         {
  406.         3, 7, 0, KING,
  407.         BLACK,
  408.         "Kg",
  409.         iblack_king,
  410.         check_king,
  411.         king_moves,
  412.         Array_els(king_moves),
  413.         127,
  414.         3,
  415.         },
  416.         {
  417.         4, 7, 0, QUEEN,
  418.         BLACK,
  419.         "Qn",
  420.         iblack_queen,
  421.         check_queen,
  422.         queen_moves,
  423.         Array_els(queen_moves),
  424.         2,
  425.         4,
  426.         },
  427.         {
  428.         5, 7, 0, BISHOP,
  429.         BLACK,
  430.         "Bp",
  431.         iblack_bishop,
  432.         check_bishop,
  433.         bishop_moves,
  434.         Array_els(bishop_moves),
  435.         4,
  436.         5,
  437.         },
  438.         {
  439.         6, 7, 0, KNIGHT,
  440.         BLACK,
  441.         "Kt",
  442.         iblack_knight,
  443.         check_knight,
  444.         knight_moves,
  445.         Array_els(knight_moves),
  446.         2,
  447.         6,
  448.         },
  449.         {
  450.         7, 7, 0, ROOK,
  451.         BLACK,
  452.         "Rk",
  453.         iblack_rook,
  454.         check_rook,
  455.         rook_moves,
  456.         Array_els(rook_moves),
  457.         6,
  458.         7,
  459.         },
  460.         {
  461.         0, 6, 0, PAWN,
  462.         BLACK,
  463.         "Pn",
  464.         iblack_pawn,
  465.         check_pawn,
  466.         bpawn_moves,
  467.         Array_els(bpawn_moves),
  468.         3,
  469.         8,
  470.         },
  471.         {
  472.         1, 6, 0, PAWN,
  473.         BLACK,
  474.         "Pn",
  475.         iblack_pawn,
  476.         check_pawn,
  477.         bpawn_moves,
  478.         Array_els(bpawn_moves),
  479.         3,
  480.         9,
  481.         },
  482.         {
  483.         2, 6, 0, PAWN,
  484.         BLACK,
  485.         "Pn",
  486.         iblack_pawn,
  487.         check_pawn,
  488.         bpawn_moves,
  489.         Array_els(bpawn_moves),
  490.         3,
  491.         10,
  492.         },
  493.         {
  494.         3, 6, 0, PAWN,
  495.         BLACK,
  496.         "Pn",
  497.         iblack_pawn,
  498.         check_pawn,
  499.         bpawn_moves,
  500.         Array_els(bpawn_moves),
  501.         3,
  502.         11,
  503.         },
  504.         {
  505.         4, 6, 0, PAWN,
  506.         BLACK,
  507.         "Pn",
  508.         iblack_pawn,
  509.         check_pawn,
  510.         bpawn_moves,
  511.         Array_els(bpawn_moves),
  512.         3,
  513.         12,
  514.         },
  515.         {
  516.         5, 6, 0, PAWN,
  517.         BLACK,
  518.         "Pn",
  519.         iblack_pawn,
  520.         check_pawn,
  521.         bpawn_moves,
  522.         Array_els(bpawn_moves),
  523.         3,
  524.         13,
  525.         },
  526.         {
  527.         6, 6, 0, PAWN,
  528.         BLACK,
  529.         "Pn",
  530.         iblack_pawn,
  531.         check_pawn,
  532.         bpawn_moves,
  533.         Array_els(bpawn_moves),
  534.         3,
  535.         14,
  536.         },
  537.         {
  538.         7, 6, 0, PAWN,
  539.         BLACK,
  540.         "Pn",
  541.         iblack_pawn,
  542.         check_pawn,
  543.         bpawn_moves,
  544.         Array_els(bpawn_moves),
  545.         3,
  546.         15,
  547.         },
  548.     };
  549.  
  550. Piece *pieces[2] = {white_pieces, black_pieces};
  551.  
  552. /* Our chessboard.  */
  553. Square board[8][8]; 
  554.  
  555. /* Some data structure for the 'artificial stupidity' algorithms to
  556.    have the ST move a piece (see droid.c) and in fact
  557.    just to check if a move is legal.  Must find out if any of the
  558.    moves could take a piece 1st, and if so dis-allow all other moves. */
  559.  
  560. Move probable_moves[
  561.     Array_els(rook_moves)*2 +
  562.     Array_els(knight_moves)*2 +
  563.     Array_els(bishop_moves)*2 +
  564.     Array_els(queen_moves) +
  565.     Array_els(king_moves) +
  566.     Array_els(wpawn_moves)*8 ];
  567. Move *sorted_moves[
  568.     Array_els(rook_moves)*2 +
  569.     Array_els(knight_moves)*2 +
  570.     Array_els(bishop_moves)*2 +
  571.     Array_els(queen_moves) +
  572.     Array_els(king_moves) +
  573.     Array_els(wpawn_moves)*8 ];
  574.  
  575. WORD probable_count;
  576. WORD sorted_count;
  577.  
  578.